// CodeGear C++Builder
// Copyright (c) 1995, 2015 by Embarcadero Technologies, Inc.
// All rights reserved

// (DO NOT EDIT: machine generated header) 'ocv.core.types_c.pas' rev: 30.00 (Windows)

#ifndef Ocv_Core_Types_cHPP
#define Ocv_Core_Types_cHPP

#pragma delphiheader begin
#pragma option push
#pragma option -w-      // All warnings off
#pragma option -Vx      // Zero-length empty class member 
#pragma pack(push,8)
#include <System.hpp>
#include <SysInit.hpp>

//-- user supplied -----------------------------------------------------------

namespace Ocv
{
namespace Core
{
namespace Types_c
{
//-- forward type declarations -----------------------------------------------
struct DECLSPEC_DRECORD TVoid
{
};


struct TCv32suf;
struct TCv64suf;
struct TIplROI;
struct TIplTileInfo;
struct TIplImage;
struct TIplConvKernel;
struct IplConvKernelFP;
struct TCvMatDataUnion;
struct TCvMat;
struct TCvMatNDdim;
struct TCvMatND;
struct TCvHistogram;
struct TCvRect;
struct TCvTermCriteria;
struct TCvPoint;
struct TCvPoint2D32f;
struct TCvPoint3D32f;
struct TCvPoint3D64f;
struct TCvPoint2D64f;
struct TCvSize;
struct TCvSize2D32f;
struct TCvBox2D;
struct TCvLineIterator;
struct TCvSlice;
struct TCvScalar;
struct TCvMemBlock;
struct TCvMemStorage;
struct TCvMemStoragePos;
struct TCvSeqBlock;
template<typename node_type> struct TCV_TREE_NODE_FIELDS__1;
struct TCvSeq;
struct TCV_SEQUENCE_FIELDS;
struct TCvContour;
template<typename elem_type> struct TCV_SET_ELEM_FIELDS__1;
struct TCvSetElem;
struct TCV_SET_FIELDS;
struct TCvSet;
struct TCvSparseMat;
struct TCvSparseNode;
struct TCvSparseMatIterator;
struct TCV_GRAPH_EDGE_FIELDS;
struct TCV_GRAPH_VERTEX_FIELDS;
struct TCvGraphEdge;
struct TCvGraphVtx;
struct TCvGraphVtx2D;
struct TCV_GRAPH_FIELDS;
struct TCvGraph;
struct TCvChain;
struct TCvSeqWriter;
struct TCvSeqReader;
struct DECLSPEC_DRECORD TCvFileStorage
{
};


struct TCvAttrList;
struct TCvString;
struct TCvFileNode;
struct TCvTypeInfo;
struct CvString;
struct TCvStringHashNode;
struct TCvPluginFuncInfo;
struct TCvModuleInfo;
//-- type declarations -------------------------------------------------------
typedef System::ByteBool cbool;

typedef float Float;

typedef NativeUInt uint;

typedef NativeUInt size_t;

typedef float *pFloat;

typedef pFloat *ppFloat;

typedef System::PPointer pPointer;

typedef System::PPointer ppvoid;

typedef System::StaticArray<float, 2> TSingleArray1D;

typedef TSingleArray1D *pSingleArray1D;

typedef System::StaticArray<pSingleArray1D, 2> TSingleArray2D;

typedef TSingleArray2D *pSingleArray2D;

typedef char CVChar;

typedef char TCVChar;

typedef char * pCVChar;

typedef System::StaticArray<char *, 1> TpCVCharArray;

typedef TpCVCharArray *ppCVChar;

typedef System::PByte puchar;

typedef void * pCvArr;

typedef System::StaticArray<void *, 1> TCvArrArray;

typedef TCvArrArray *pCvArrArray;

struct DECLSPEC_DRECORD TCv32suf
{
	
public:
	union
	{
		struct 
		{
			float f;
		};
		struct 
		{
			unsigned u;
		};
		struct 
		{
			int i;
		};
		
	};
};


struct DECLSPEC_DRECORD TCv64suf
{
	
public:
	union
	{
		struct 
		{
			double f;
		};
		struct 
		{
			unsigned __int64 u;
		};
		struct 
		{
			__int64 i;
		};
		
	};
};


typedef unsigned __int64 TCvRNG;

typedef unsigned __int64 *pCvRNG;

typedef TIplImage *pIplImage;

typedef System::StaticArray<pIplImage, 2> TpIplImageArray;

typedef System::DynamicArray<pIplImage> TArrayOfpIplImage;

typedef TpIplImageArray *ppIplImage;

typedef TIplROI *pIplROI;

typedef TIplTileInfo *pIplTileInfo;

struct DECLSPEC_DRECORD TIplROI
{
public:
	int coi;
	int xOffset;
	int yOffset;
	int width;
	int height;
};


typedef void __cdecl (*TiplCallBack)(pIplImage img, int xIndex, int yIndex, int mode);

struct DECLSPEC_DRECORD TIplTileInfo
{
public:
	TiplCallBack callBack;
	void *id;
	char *tileData;
	int width;
	int height;
};


typedef System::StaticArray<char, 4> TA4CVChar;

struct DECLSPEC_DRECORD TIplImage
{
public:
	int nSize;
	int id;
	int nChannels;
	int alphaChannel;
	int depth;
	TA4CVChar colorModel;
	TA4CVChar channelSeq;
	int dataOrder;
	int origin;
	int align;
	int width;
	int height;
	TIplROI *roi;
	TIplImage *maskROI;
	void *imageId;
	TIplTileInfo *tileInfo;
	int imageSize;
	System::Byte *imageData;
	int widthStep;
	System::StaticArray<int, 4> BorderMode;
	System::StaticArray<int, 4> BorderConst;
	System::Byte *imageDataOrigin;
};


typedef TIplImage TcvImage;

typedef pIplImage pcvImage;

typedef TIplConvKernel *pIplConvKernel;

struct DECLSPEC_DRECORD TIplConvKernel
{
public:
	int nCols;
	int nRows;
	int anchorX;
	int anchorY;
	int *values;
	int nShiftR;
};


struct DECLSPEC_DRECORD IplConvKernelFP
{
public:
	int nCols;
	int nRows;
	int anchorX;
	int anchorY;
	float *values;
};


typedef TCvMat *pCvMat;

typedef pCvMat *ppCvMat;

struct DECLSPEC_DRECORD TCvMatDataUnion
{
	
public:
	union
	{
		struct 
		{
			double *db;
		};
		struct 
		{
			float *fl;
		};
		struct 
		{
			int *i;
		};
		struct 
		{
			short *s;
		};
		struct 
		{
			System::Byte *ptr;
		};
		
	};
};


struct DECLSPEC_DRECORD TCvMat
{
public:
	int _type;
	int step;
	int *refcount;
	int hdr_refcount;
	TCvMatDataUnion data;
	int rows;
	int cols;
	
private:
	System::Byte __fastcall GetMatByte(const int row, const int col);
	double __fastcall GetMatDouble(const int row, const int col);
	int __fastcall GetMatInteger(const int row, const int col);
	float __fastcall GetMatSingle(const int row, const int col);
	void __fastcall SetMatByte(const int row, const int col, const System::Byte Value);
	void __fastcall SetMatDouble(const int row, const int col, const double Value);
	void __fastcall SetMatInteger(const int row, const int col, const int Value);
	void __fastcall SetMatSingle(const int row, const int col, const float Value);
	
public:
	System::PDouble __fastcall AsDouble(void);
	System::PInteger __fastcall AsInteger(void);
	System::PByte __fastcall AsByte(void);
	System::PSingle __fastcall AsSingle(void);
	__property double MatDouble[const int row][const int col] = {read=GetMatDouble, write=SetMatDouble};
	__property float MatSingle[const int row][const int col] = {read=GetMatSingle, write=SetMatSingle};
	__property int MatInteger[const int row][const int col] = {read=GetMatInteger, write=SetMatInteger};
	__property System::Byte MatByte[const int row][const int col] = {read=GetMatByte, write=SetMatByte};
};


struct DECLSPEC_DRECORD TCvMatNDdim
{
public:
	int size;
	int step;
};


typedef TCvMatDataUnion TCvMatNDdata;

typedef TCvMatND *pCvMatND;

struct DECLSPEC_DRECORD TCvMatND
{
public:
	int _type;
	int dims;
	int *refcount;
	int hdr_refcount;
	TCvMatDataUnion data;
	System::StaticArray<TCvMatNDdim, 32> dim;
};


typedef TCvHistogram *pCvHistogram;

struct DECLSPEC_DRECORD TCvHistogram
{
public:
	int _type;
	TIplImage *bins;
	System::StaticArray<System::StaticArray<float, 2>, 32> thresh;
	float *thresh2;
	TCvMatND mat;
};


typedef TCvRect *pCvRect;

struct DECLSPEC_DRECORD TCvRect
{
public:
	int x;
	int y;
	int width;
	int height;
};


typedef TCvTermCriteria *pCvTermCriteria;

struct DECLSPEC_DRECORD TCvTermCriteria
{
public:
	int cType;
	int max_iter;
	double epsilon;
};


typedef TCvPoint *pCvPoint;

struct DECLSPEC_DRECORD TCvPoint
{
public:
	int x;
	int y;
};


typedef System::StaticArray<TCvPoint, 101> TCvPointArray;

typedef TCvPointArray *pCvPointArray;

typedef TCvPoint2D32f *pCvPoint2D32f;

struct DECLSPEC_DRECORD TCvPoint2D32f
{
public:
	float x;
	float y;
	static TCvPoint2D32f __fastcall _op_Subtraction(const TCvPoint2D32f &a, const TCvPoint2D32f &b);
	float __fastcall Norm(void);
	TCvPoint __fastcall cvPoint(void);
};


typedef TCvPoint2D32f TcvPoint2f;

typedef pCvPoint2D32f pcvPoint2f;

typedef System::DynamicArray<TCvPoint2D32f> TArrayOfcvPoint2f;

typedef TCvPoint3D32f *pCvPoint3D32f;

struct DECLSPEC_DRECORD TCvPoint3D32f
{
public:
	float x;
	float y;
	float z;
};


typedef TCvPoint3D64f *pCvPoint3D64f;

struct DECLSPEC_DRECORD TCvPoint3D64f
{
public:
	double x;
	double y;
	double z;
};


typedef TCvPoint2D64f *pCvPoint2D64f;

struct DECLSPEC_DRECORD TCvPoint2D64f
{
public:
	double x;
	double y;
};


typedef TCvSize *pCvSize;

struct DECLSPEC_DRECORD TCvSize
{
public:
	int width;
	int height;
};


typedef TCvSize2D32f *pCvSize2D32f;

struct DECLSPEC_DRECORD TCvSize2D32f
{
public:
	float width;
	float height;
};


typedef TCvBox2D *pCvBox2D;

struct DECLSPEC_DRECORD TCvBox2D
{
public:
	TCvPoint2D32f center;
	TCvSize2D32f size;
	float angle;
};


typedef TCvLineIterator *pCvLineIterator;

struct DECLSPEC_DRECORD TCvLineIterator
{
public:
	System::Byte *ptr;
	int err;
	int plus_delta;
	int minus_delta;
	int plus_step;
	int minus_step;
};


struct DECLSPEC_DRECORD TCvSlice
{
public:
	int start_index;
	int end_index;
};


typedef TCvScalar *pCvScalar;

struct DECLSPEC_DRECORD TCvScalar
{
public:
	System::StaticArray<double, 4> val;
	static bool __fastcall _op_LessThan(const TCvScalar &a, const TCvScalar &b);
	static bool __fastcall _op_GreaterThan(const TCvScalar &a, const TCvScalar &b);
};


typedef TCvMemBlock *pCvMemBlock;

struct DECLSPEC_DRECORD TCvMemBlock
{
public:
	TCvMemBlock *prev;
	TCvMemBlock *next;
};


typedef TCvMemStorage *pCvMemStorage;

struct DECLSPEC_DRECORD TCvMemStorage
{
public:
	int signature;
	TCvMemBlock *bottom;
	TCvMemBlock *top;
	TCvMemStorage *parent;
	int block_size;
	int free_space;
};


typedef TCvMemStoragePos *pCvMemStoragePos;

struct DECLSPEC_DRECORD TCvMemStoragePos
{
public:
	TCvMemBlock *top;
	int free_space;
};


typedef TCvSeqBlock *pCvSeqBlock;

struct DECLSPEC_DRECORD TCvSeqBlock
{
public:
	TCvSeqBlock *prev;
	TCvSeqBlock *next;
	int start_index;
	int count;
	void *data;
};


typedef System::StaticArray<TCvSeqBlock, 1> TCvSeqBlockArray;

typedef TCvSeqBlockArray *pCvSeqBlockArray;

// Template declaration generated by Delphi parameterized types is
// used only for accessing Delphi variables and fields.
// Don't instantiate with new type parameters in user code.
template<typename node_type> struct DECLSPEC_DRECORD TCV_TREE_NODE_FIELDS__1
{
	
public:
	typedef node_type *_1;
	
	typedef node_type *_2;
	
	typedef node_type *_3;
	
	typedef node_type *_4;
	
	
public:
	int flags;
	int header_size;
	_1 h_prev;
	_2 h_next;
	_3 v_prev;
	_4 v_next;
};


typedef TCvSeq *pCvSeq;

struct DECLSPEC_DRECORD TCvSeq
{
public:
	int flags;
	int header_size;
	TCvSeq *h_prev;
	TCvSeq *h_next;
	TCvSeq *v_prev;
	TCvSeq *v_next;
	int total;
	int elem_size;
	void *block_max;
	System::Int8 *ptr;
	int delta_elems;
	TCvMemStorage *storage;
	TCvSeqBlock *free_blocks;
	TCvSeqBlock *first;
};


typedef TCV_TREE_NODE_FIELDS__1<TCvSeq> TCV_TREE_NODE_FIELDS_TCvSeq;

struct DECLSPEC_DRECORD TCV_SEQUENCE_FIELDS
{
public:
	TCV_TREE_NODE_FIELDS__1<TCvSeq> CV_TREE_NODE_FIELDS;
	int total;
	int elem_size;
	System::Int8 *block_max;
	System::Int8 *ptr;
	int delta_elems;
	TCvMemStorage *storage;
	TCvSeqBlock *free_blocks;
	TCvSeqBlock *first;
};


typedef System::StaticArray<pCvSeq, 2> pCvSeqArray;

typedef pCvSeqArray *ppCvSeq;

typedef TCvContour *pCvContour;

struct DECLSPEC_DRECORD TCvContour
{
public:
	int flags;
	int header_size;
	void *h_prev;
	void *h_next;
	void *v_prev;
	void *v_next;
	int total;
	int elem_size;
	char *block_max;
	char *ptr;
	int delta_elems;
	TCvMemStorage *storage;
	TCvSeqBlock *free_blocks;
	TCvSeqBlock *first;
	TCvRect rect;
	int color;
	System::StaticArray<int, 3> reserved;
};


// Template declaration generated by Delphi parameterized types is
// used only for accessing Delphi variables and fields.
// Don't instantiate with new type parameters in user code.
template<typename elem_type> struct DECLSPEC_DRECORD TCV_SET_ELEM_FIELDS__1
{
	
public:
	typedef elem_type *_1;
	
	
public:
	int flags;
	_1 next_free;
};


typedef TCvSetElem *pCvSetElem;

struct DECLSPEC_DRECORD TCvSetElem
{
public:
	int flags;
	TCvSetElem *next_free;
};


typedef System::StaticArray<TCvSetElem, 1> TCvSetElemArray;

typedef TCvSetElemArray *pCvSetElemArray;

struct DECLSPEC_DRECORD TCV_SET_FIELDS
{
public:
	TCV_SEQUENCE_FIELDS CV_SEQUENCE_FIELDS;
	TCvSetElem *free_elems;
	int active_count;
};


typedef TCvSet *pCvSet;

struct DECLSPEC_DRECORD TCvSet
{
public:
	int flags;
	int header_size;
	TCvSeq *h_prev;
	TCvSeq *h_next;
	TCvSeq *v_prev;
	TCvSeq *v_next;
	int total;
	int elem_size;
	void *block_max;
	void *ptr;
	int delta_elems;
	TCvMemStorage *storage;
	TCvSeqBlock *free_blocks;
	TCvSeqBlock *first;
	TCvSetElem *free_elems;
	int active_count;
};


typedef TCvSparseMat *pCvSparseMat;

struct DECLSPEC_DRECORD TCvSparseMat
{
public:
	int cType;
	int dims;
	int *refcount;
	int hdr_refcount;
	TCvSet *heap;
	void * *hashtable;
	int hashsize;
	int valoffset;
	int idxoffset;
	System::StaticArray<int, 32> size;
};


typedef TCvSparseNode *pCvSparseNode;

struct DECLSPEC_DRECORD TCvSparseNode
{
public:
	unsigned hashval;
	TCvSparseNode *next;
};


typedef TCvSparseMatIterator *pCvSparseMatIterator;

struct DECLSPEC_DRECORD TCvSparseMatIterator
{
public:
	TCvSparseMat *mat;
	TCvSparseNode *node;
	int curidx;
};


typedef TCvGraphEdge *pCvGraphEdge;

typedef TCvGraphVtx *pCvGraphVtx;

struct DECLSPEC_DRECORD TCV_GRAPH_EDGE_FIELDS
{
public:
	int flags;
	float weight;
	System::StaticArray<pCvGraphEdge, 2> next;
	System::StaticArray<pCvGraphVtx, 2> vtx;
};


struct DECLSPEC_DRECORD TCV_GRAPH_VERTEX_FIELDS
{
public:
	int flags;
	TCvGraphEdge *first;
};


struct DECLSPEC_DRECORD TCvGraphEdge
{
public:
	TCV_GRAPH_EDGE_FIELDS CV_GRAPH_EDGE_FIELDS;
};


typedef System::StaticArray<pCvGraphEdge, 1> TCvGraphEdgeArray;

typedef TCvGraphEdgeArray *pCvGraphEdgeArray;

struct DECLSPEC_DRECORD TCvGraphVtx
{
public:
	TCV_GRAPH_VERTEX_FIELDS CV_GRAPH_VERTEX_FIELDS;
};


typedef System::StaticArray<pCvGraphVtx, 1> TCvGraphVtxArray;

typedef TCvGraphVtxArray *pCvGraphVtxArray;

typedef TCvGraphVtx2D *pCvGraphVtx2D;

struct DECLSPEC_DRECORD TCvGraphVtx2D
{
public:
	TCV_GRAPH_VERTEX_FIELDS CV_GRAPH_VERTEX_FIELDS;
	TCvPoint2D32f *ptr;
};


struct DECLSPEC_DRECORD TCV_GRAPH_FIELDS
{
public:
	TCV_SET_FIELDS CV_SET_FIELDS;
	TCvSet *edges;
};


typedef TCvGraph *pCvGraph;

struct DECLSPEC_DRECORD TCvGraph
{
public:
	TCV_GRAPH_FIELDS CV_GRAPH_FIELDS;
	TCvSet *edges;
};


typedef TCvChain *pCvChain;

struct DECLSPEC_DRECORD TCvChain
{
public:
	TCvPoint origin;
};


typedef TCvSeqWriter *pCvSeqWriter;

struct DECLSPEC_DRECORD TCvSeqWriter
{
public:
	int header_size;
	TCvSeq *Seq;
	TCvSeqBlock *block;
	void *ptr;
	void *block_min;
	void *block_max;
};


typedef TCvSeqReader *pCvSeqReader;

struct DECLSPEC_DRECORD TCvSeqReader
{
public:
	int header_size;
	TCvSeq *Seq;
	TCvSeqBlock *block;
	void *ptr;
	void *block_min;
	void *block_max;
	int delta_index;
	void *prev_elem;
};


typedef TCvFileStorage *pCvFileStorage;

typedef TCvAttrList *pCvAttrList;

struct DECLSPEC_DRECORD TCvAttrList
{
public:
	TpCVCharArray *attr;
	TCvAttrList *next;
};


typedef TCvString *pCvString;

struct DECLSPEC_DRECORD TCvString
{
public:
	int len;
	char *ptr;
};


typedef TCvFileNode *pCvFileNode;

typedef TCvTypeInfo *pCvTypeInfo;

typedef void * pCvFileNodeHash;

struct DECLSPEC_DRECORD TCvFileNode
{
public:
	int tag;
	TCvTypeInfo *info;
	
public:
	union
	{
		struct 
		{
			void *map;
		};
		struct 
		{
			TCvSeq *Seq;
		};
		struct 
		{
			TCvString str;
		};
		struct 
		{
			int i;
		};
		struct 
		{
			double f;
		};
		
	};
};


typedef int __cdecl (*TCvIsInstanceFunc)(void * &struct_ptr);

typedef void __cdecl (*TCvReleaseFunc)(System::PPointer struct_dblptr);

typedef void * __cdecl (*TCvReadFunc)(pCvFileStorage storage, pCvFileNode node);

typedef void __cdecl (*TCvWriteFunc)(pCvFileStorage storage, const char * name, const System::PPointer struct_ptr, const TCvAttrList attributes);

typedef void * __cdecl (*TCvCloneFunc)(const System::PPointer struct_ptr);

struct DECLSPEC_DRECORD TCvTypeInfo
{
public:
	int flags;
	int header_size;
	TCvTypeInfo *prev;
	TCvTypeInfo *next;
	char *type_name;
	TCvIsInstanceFunc is_instance;
	TCvReleaseFunc release;
	TCvReadFunc read;
	TCvWriteFunc write;
	TCvCloneFunc clone;
};


struct DECLSPEC_DRECORD CvString
{
public:
	int len;
	char *ptr;
};


typedef TCvStringHashNode *pCvStringHashNode;

struct DECLSPEC_DRECORD TCvStringHashNode
{
public:
	unsigned hashval;
	TCvString str;
	TCvStringHashNode *next;
};


typedef TCvPluginFuncInfo *PCvPluginFuncInfo;

struct DECLSPEC_DRECORD TCvPluginFuncInfo
{
public:
	void * *func_addr;
	void *default_func_addr;
	char *func_names;
	int search_modules;
	int loaded_from;
};


typedef TCvModuleInfo *PCvModuleInfo;

struct DECLSPEC_DRECORD TCvModuleInfo
{
public:
	TCvModuleInfo *next;
	char *name;
	char *version;
	TCvPluginFuncInfo *func_tab;
};


//-- var, const, procedure ---------------------------------------------------
static const System::Extended DBL_EPSILON = 2.220446E-16;
static const System::Extended DBL_MAX = 1.797693E+308;
static const System::Extended FLT_EPSILON = 1.192093E-07;
static const System::Extended FLT_MAX = 1.000000E+37;
static const System::Int8 CV_StsOk = System::Int8(0x0);
static const System::Int8 CV_StsBackTrace = System::Int8(-1);
static const System::Int8 CV_StsError = System::Int8(-2);
static const System::Int8 CV_StsInternal = System::Int8(-3);
static const System::Int8 CV_StsNoMem = System::Int8(-4);
static const System::Int8 CV_StsBadArg = System::Int8(-5);
static const System::Int8 CV_StsBadFunc = System::Int8(-6);
static const System::Int8 CV_StsNoConv = System::Int8(-7);
static const System::Int8 CV_StsAutoTrace = System::Int8(-8);
static const System::Int8 CV_HeaderIsNull = System::Int8(-9);
static const System::Int8 CV_BadImageSize = System::Int8(-10);
static const System::Int8 CV_BadOffset = System::Int8(-11);
static const System::Int8 CV_BadDataPtr = System::Int8(-12);
static const System::Int8 CV_BadStep = System::Int8(-13);
static const System::Int8 CV_BadModelOrChSeq = System::Int8(-14);
static const System::Int8 CV_BadNumChannels = System::Int8(-15);
static const System::Int8 CV_BadNumChannel1U = System::Int8(-16);
static const System::Int8 CV_BadDepth = System::Int8(-17);
static const System::Int8 CV_BadAlphaChannel = System::Int8(-18);
static const System::Int8 CV_BadOrder = System::Int8(-19);
static const System::Int8 CV_BadOrigin = System::Int8(-20);
static const System::Int8 CV_BadAlign = System::Int8(-21);
static const System::Int8 CV_BadCallBack = System::Int8(-22);
static const System::Int8 CV_BadTileSize = System::Int8(-23);
static const System::Int8 CV_BadCOI = System::Int8(-24);
static const System::Int8 CV_BadROISize = System::Int8(-25);
static const System::Int8 CV_MaskIsTiled = System::Int8(-26);
static const System::Int8 CV_StsNullPtr = System::Int8(-27);
static const System::Int8 CV_StsVecLengthErr = System::Int8(-28);
static const System::Int8 CV_StsFilterStructContentErr = System::Int8(-29);
static const System::Int8 CV_StsKernelStructContentErr = System::Int8(-30);
static const System::Int8 CV_StsFilterOffsetErr = System::Int8(-31);
static const short CV_StsBadSize = short(-201);
static const short CV_StsDivByZero = short(-202);
static const short CV_StsInplaceNotSupported = short(-203);
static const short CV_StsObjectNotFound = short(-204);
static const short CV_StsUnmatchedFormats = short(-205);
static const short CV_StsBadFlag = short(-206);
static const short CV_StsBadPoint = short(-207);
static const short CV_StsBadMask = short(-208);
static const short CV_StsUnmatchedSizes = short(-209);
static const short CV_StsUnsupportedFormat = short(-210);
static const short CV_StsOutOfRange = short(-211);
static const short CV_StsParseError = short(-212);
static const short CV_StsNotImplemented = short(-213);
static const short CV_StsBadMemBlock = short(-214);
static const short CV_StsAssert = short(-215);
static const short CV_GpuNotSupported = short(-216);
static const short CV_GpuApiCallError = short(-217);
static const short CV_OpenGlNotSupported = short(-218);
static const short CV_OpenGlApiCallError = short(-219);
static const System::Int8 CV_INTER_NN = System::Int8(0x0);
static const System::Int8 CV_INTER_LINEAR = System::Int8(0x1);
static const System::Int8 CV_INTER_CUBIC = System::Int8(0x2);
static const System::Int8 CV_INTER_AREA = System::Int8(0x3);
static const System::Int8 CV_INTER_LANCZOS4 = System::Int8(0x4);
#define CV_TYPE_NAME_IMAGE L"opencv-image"
extern DELPHI_PACKAGE TCvPoint cvZeroPoint;
extern DELPHI_PACKAGE TCvSize ZeroCvSize;
#define CV_TYPE_NAME_GRAPH L"opencv-graph"
extern DELPHI_PACKAGE TCvAttrList ZeroCvAttrList;
extern DELPHI_PACKAGE TCvRect cvZeroRect;
extern DELPHI_PACKAGE char * __fastcall strdup(const char * str);
extern DELPHI_PACKAGE int __fastcall cv_stricmp(const char * str1, const char * str2);
extern DELPHI_PACKAGE void __fastcall strcpy(char * &str1, const char * str2)/* overload */;
extern DELPHI_PACKAGE void __fastcall strcpync(const char * str1, const char * str2)/* overload */;
extern DELPHI_PACKAGE void __fastcall strcat(char * &str1, const char * str2);
extern DELPHI_PACKAGE void * __fastcall CV_MAT_ELEM_PTR_FAST(const TCvMat &mat, const int row, const int col, const int pix_size);
extern DELPHI_PACKAGE void * __fastcall CV_MAT_ELEM(const TCvMat &mat, const int elemsize, const int row, const int col);
extern DELPHI_PACKAGE TCvAttrList __fastcall CvAttrList(const ppCVChar attr = (ppCVChar)(0x0), pCvAttrList next = (pCvAttrList)(0x0));
extern DELPHI_PACKAGE int __fastcall CV_MAT_DEPTH(const int flags);
extern DELPHI_PACKAGE int __fastcall CV_MAT_TYPE(const int flags);
extern DELPHI_PACKAGE int __fastcall CV_MAT_CN(const int flags);
extern DELPHI_PACKAGE int __fastcall CV_ELEM_SIZE(const int _type);
extern DELPHI_PACKAGE int __fastcall CV_32SC1(void);
extern DELPHI_PACKAGE int __fastcall CV_32FC1(void);
extern DELPHI_PACKAGE int __fastcall CV_MAKETYPE(int depth, int cn);
extern DELPHI_PACKAGE TCvMat __fastcall cvMat(const int rows, const int cols, int etype, void * data = (void *)(0x0));
extern DELPHI_PACKAGE TCvScalar __fastcall cvScalarAll(double val0123);
extern DELPHI_PACKAGE TCvPoint __fastcall cvPoint(const int x = 0x0, const int y = 0x0);
extern DELPHI_PACKAGE TCvPoint2D32f __fastcall CvPoint2f(const float x = 0.000000E+00f, const float y = 0.000000E+00f);
extern DELPHI_PACKAGE TCvScalar __fastcall CvScalar(const double val0, const double val1 = 0.000000E+00, const double val2 = 0.000000E+00, const double val3 = 0.000000E+00);
extern DELPHI_PACKAGE TCvSize __fastcall CvSize(const int width, const int height);
extern DELPHI_PACKAGE TCvRect __fastcall CvRect(const int x, const int y, const int width, const int height);
extern DELPHI_PACKAGE unsigned __fastcall cvRandInt(unsigned __int64 &rng);
extern DELPHI_PACKAGE int __fastcall cvRound(double Value);
extern DELPHI_PACKAGE System::Variant __fastcall iif(const bool Conditional, const System::Variant &ifTrue, const System::Variant &ifFalse)/* overload */;
extern DELPHI_PACKAGE void * __fastcall iif(const bool Conditional, const void * ifTrue, const void * ifFalse)/* overload */;
extern DELPHI_PACKAGE int __fastcall CV_NODE_TYPE(const int flags);
extern DELPHI_PACKAGE bool __fastcall CV_NODE_IS_INT(const int flags);
extern DELPHI_PACKAGE bool __fastcall CV_NODE_IS_REAL(const int flags);
extern DELPHI_PACKAGE bool __fastcall CV_NODE_IS_STRING(const int flags);
extern DELPHI_PACKAGE void __fastcall CV_READ_SEQ_ELEM(const void * Elem, const TCvSeqReader &Reader, const int SizeOfElem);
extern DELPHI_PACKAGE void __fastcall CV_NEXT_SEQ_ELEM(const int elem_size, const TCvSeqReader &Reader);
extern DELPHI_PACKAGE int __fastcall cvFloor(double Value);
extern DELPHI_PACKAGE TCvPoint __fastcall cvPointFrom32f(const TCvPoint2D32f &point);
extern DELPHI_PACKAGE TCvTermCriteria __fastcall CvTermCriteria(int _type, int max_iter, double epsilon);
extern DELPHI_PACKAGE TCvPoint2D32f __fastcall cvPointTo32f(const TCvPoint &point);
extern DELPHI_PACKAGE TCvPoint2D32f __fastcall CvPoint2D32f(float x, float y);
extern DELPHI_PACKAGE TCvPoint3D32f __fastcall cvPoint3D32f(const float x, const float y, const float z);
extern DELPHI_PACKAGE void __fastcall CV_SWAP(void * &a, void * &b, void * &T)/* overload */;
extern DELPHI_PACKAGE void __fastcall CV_SWAP(void * &a, void * &b)/* overload */;
extern DELPHI_PACKAGE void __fastcall CV_SWAP(pCvMat &a, pCvMat &b, pCvMat &T)/* overload */;
extern DELPHI_PACKAGE void __fastcall CV_SWAP(pIplImage &a, pIplImage &b, pIplImage &T)/* overload */;
extern DELPHI_PACKAGE void __fastcall CV_SWAP(pIplImage &a, pIplImage &b)/* overload */;
extern DELPHI_PACKAGE void __fastcall CV_SWAP(pCvPoint2D32f &a, pCvPoint2D32f &b, pCvPoint2D32f &T)/* overload */;
extern DELPHI_PACKAGE void __fastcall CV_SWAP(pCvPoint2D32f &a, pCvPoint2D32f &b)/* overload */;
extern DELPHI_PACKAGE System::Byte __fastcall CV_CAST_8U(int T);
extern DELPHI_PACKAGE void * __fastcall CV_GET_SEQ_ELEM(const int size_of_elem, pCvSeq Seq, int index);
extern DELPHI_PACKAGE void * __fastcall CV_SEQ_ELEM(pCvSeq Seq, const int size_of_elem, int index);
extern DELPHI_PACKAGE bool __fastcall CV_IS_SET_ELEM(void * ptr);
extern DELPHI_PACKAGE void * __fastcall CV_IMAGE_ELEM(pIplImage image, int size_elemtype, int row, int col);
extern DELPHI_PACKAGE TCvScalar __fastcall cvRealScalar(double val0);
extern DELPHI_PACKAGE unsigned __int64 __fastcall cvRNG(__int64 seed = -1LL);
extern DELPHI_PACKAGE int __fastcall CV_ELEM_SIZE1(const int _type);
extern DELPHI_PACKAGE int __fastcall cvIplDepth(int _type);
extern DELPHI_PACKAGE bool __fastcall CV_ARE_TYPES_EQ(const pCvMat mat1, const pCvMat mat2);
extern DELPHI_PACKAGE bool __fastcall CV_IS_SEQ_CLOSED(const pCvSeq Seq);
extern DELPHI_PACKAGE bool __fastcall CV_IS_SEQ_HOLE(const pCvSeq Seq);
extern DELPHI_PACKAGE TCvBox2D __fastcall CvBox2D(const float cX, const float cY, const float width, const float height, const float angle);
extern DELPHI_PACKAGE TCvSize2D32f __fastcall CvSize2D32f(const float width, const float height);
extern DELPHI_PACKAGE bool __fastcall CV_IS_MATND_HDR(const void * mat);
extern DELPHI_PACKAGE bool __fastcall CV_IS_MATND(const void * mat);
extern DELPHI_PACKAGE bool __fastcall CV_IS_MAT(const void * mat);
extern DELPHI_PACKAGE bool __fastcall CV_IS_MAT_HDR(const void * mat);
}	/* namespace Types_c */
}	/* namespace Core */
}	/* namespace Ocv */
#if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_OCV_CORE_TYPES_C)
using namespace Ocv::Core::Types_c;
#endif
#if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_OCV_CORE)
using namespace Ocv::Core;
#endif
#if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_OCV)
using namespace Ocv;
#endif
#pragma pack(pop)
#pragma option pop

#pragma delphiheader end.
//-- end unit ----------------------------------------------------------------
#endif	// Ocv_Core_Types_cHPP
